Массивы и их типы

Понятие массива

Массив есть совокупность m – произвольных объектов и совокупность
I – упорядоченных наборов вида (i₁, i₂, …, i_n). Причем имеется взаимно однозначное соответствие между элементами m и наборами (i₁, i₂, …, i_n) Î I, где i_p (p = 1, 2, …, n) принимает значения соответственно в упорядоченном наборе (a_p,1, a_p,2, …, a_{p, s(p)}) из s(p) произвольных различных элементов. Здесь n – натуральное число и s(p) – некоторая функция с натуральными значениями, определенная на множестве {1, 2, …, n}.

При работе с массивами используется такая терминология. Параметр n называется размерностью массива, величины p – измерениями массива, элементы i_p – индексами массива вдоль измерения p, значения s(p) – размерами массива вдоль измерения p (p = 1, 2, …, n). Общее количество элементов в m равно s(1)*s(2)*…*s(n). Если конкретному элементу из m соответствует набор индексов (i₁, i₂, …, i_n) Î I, то этот элемент обозначают через m[i₁, i₂, …, i_n]. Массивы размерности n = 1 называют одномерным или, по-другому, векторами. Массивы размерности n = 2 называют двумерным или, по-другому, матрицами. Массивы размерности n называют n-мерными массивами. В Maple допускаются также нуль-мерные массивы.

Обычно массивы классифицируют по размерности или по типу составляющих их элементов. В Maple массивы отличаются друг от друга, прежде всего, способами описания их структуры, которые и задают имена типам массивов. Так, что массивы с одним и тем же типом элементов и даже одинаковой размерности могут быть разного типа. Например, двумерный массив в Maple может иметь тип Matrix, Array, matrix и array. Рассматриваются массивы и с составными (интегрированными) типами, учитывающими как способ их описания, так и тип их элементов. Например, Matrix[integer] – массивы типа Matrix с элементами целочисленного типа, Vector[float[8]] – массивы типа Vector с восьми байтовыми элементами вещественного типа и т. д. С типом массивов и типом составляющих их элементов непосредственно связан набор предоставляемых средств для их обработки.

В Maple наиболее продвинутым и используемым типом массивов является rtable и его подтипы Matrix (матрицы типа Matrix), Vector (векторы типа Vector), Array (массивы типа Array размерности от 0 до 63). Кроме того, имеются также типы table (таблицы) и array с подтипами matrix и vector. С помощью функции convert можно осуществлять преобразования типов массивов. В массиве любого типа допускается наличие элементов разного типа. Если никаких ограничений на тип элементов массива не накладывается, то считается, что они имеют тип anything (любой).

C помощью функции map можно проводить различные групповые операции над элементами массивов. Например, по map(simplify, m) все элементы массива m упрощаются, а по map(diff, m, x) – дифференцируются по x.

Массивы типа rtable

Массивы типа rtable с подтипами Matrix, Vector и Array являются основными структурами данных, которыми оперируют многочисленные средства надежного и эффективного пакета расширений LinearAlgebra, разработанного известной группой математиков и программистов NAG (Numerical Algorithms Group) для решения разнообразных задач линейной алгебры. В настоящее время пакет LinearAlgebra практически по всем позициям превосходит аналогичный пакет расширений linalg, который широко использовался в предыдущих версиях Maple.

Быстрое создание векторов и матриц

Наряду с простыми и вложенными списками в Maple используются объекты, называемые угловыми списками. По синтаксису они отличающиеся от списков ограничивающими скобками и (или) разделителями элементов. А именно, в обычных списках ограничители – квадратные скобки “[” и “]”, а разделители – запятые “,”. В угловых скобках ограничители – угловые скобки “<” и “>”, а разделители – запятые “,” или вертикальные черточки “|”. Угловые скобки применяются в качестве конструкторов для быстрого создания массивов типа Matrix и Vector, являющихся подтипами типа rtable. Еще один способ быстрого создания векторов и матриц предоставляется палитрой Matrix.

Конструктор <a, b, …, c> создает вектор-столбец типа Vector с компонентами a, b, …, c.

Конструктор <a | b | …| c> создает вектор-строку типа Vector с компонентами a, b, …, c.

Конструктор <<a1, a2, …, am> | … | <c1, c2, …, cm >>. Все внутренние угловые списки должны иметь одну и ту же длину. Здесь создается массив типа Matrix, в котором элементы внутренних угловых списков размещаются в соответствующих строках матрицы. В угловых списках второго уровня вложенности пары соответствующих друг другу угловых скобок игнорируются.

Конструктор <<a1 | a2 | …| am> , … , <c1 | c2 | …| cm >>. Все внутренние угловые списки должны иметь одну и ту же длину. Создается массив типа Matrix, в котором элементы внутренних угловых списков размещаются в соответствующих столбцах матрицы.

Замечания.

1. Угловые скобки можно использовать для подсодинения массивов друг к другу по строкам и по столбцам (см. примеры).

2. Массивы размерности более двух с помощью угловых списков создавать нельзя.

Примеры 1. Быстрое создание массивов типа Matrix или Vector конструктором < >.

>	restart: v := <1, 2, 3>: w := <1 | 2 | 3>:	{¿}
	v, w, type(v, Vector), type(w, Vector);	{¿}
>	m1 := <<1, 2> | <3, 4> | <5, 6>>:	{Shift+¿}
	m2 := <<a | c | e>, <b | d | f>>:	{Shift+¿}
	m1, type(m1, Matrix), type(m1, rtable);	{¿}
>	m2, type(m2, Matrix), type(m2, rtable);	{¿}
>	<<m1> | <m2>>, <<m1>, <m2>>;	{¿}

Создание векторов и матриц через палитру Matrix

Палитра Matrix. Через палитру Matrix можно создавать векторы типа Vector (Vector[row], Vector[column]) и матрицы типа Matrix.

В поля Rows (строки) и Columns (столбцы) вводятся размеры создаваемого объекта. Делать это можно тремя способами: прямым вводом требуемых значений в поля ввода, щелчками левой кнопкой мыши по кнопкам-счетчикам, находящимся в правой части этих полей, и, наконец, протягиванием курсора по клеткам шаблона матрицы, раскрываемого кнопкой Choose.

Выборами списка Type задается тип создаваемого объекта. Возможные выборы здесь таковы: Custom values – объект с неопределенными элементами, значения которых будут заданы пользователем позже, Zero-filled – объект с нулевыми элементами, One-filled – объект с единичными элементами, Identity – единичная матрица или единичный вектор, Random – объект с целыми случайными элементами, равномерно-распределенными в диапазоне -99.. 99.

Выборами списка DataType задается тип элементов создаваемого объекта. Возможные выборы здесь таковы: Any – элементы могут иметь любой тип, integer[n] (n Î {1, 2, 4, 8}) – элементы должны быть n-байтовыми целыми числами, float[8] – элементы должны быть 8-байтовыми числами с плавающей точкой, complex[8] – элементы должны быть 8-байтовыми комплексными числами (по 8 байтов для действительной и для комплексной частей числа).

Выборами списка Shape задается форма объекта. В раскрытом виде этот список приведен в правой части рисунка 2. Все выборы этого списка описаны в опциях shape конструктора матриц Matrix и конструктора векторов Vector.

Объект со свойствами, определенными установленными значениями полей и списков палитры Matrix вставляется в документ с текущей позиции курсора. Делается это щелчком левой кнопки мыши по кнопке с переменной надписью “Insert …” (Insert Matrix, Insert Vector[row], Inset Vector[column]) или по шаблону матрицы, находящемуся слева от этой кнопки. При этом в документ вставляется тот объект, который указан в надписи кнопки “Insert …”. Поля и списки палитры могут задавать объект неоднозначно. Например, при Rows = 1 объект может быть и матрицей и вектором. В этом случае выбор между его альтернативами осуществляется из раскрывающего по кнопке “Insert …” списка. Шаблон матрицы можно также использовать для вставки объектов в документ технологией Drag and Drop (тащи и бросай). Для создания в документе именованного объекта курсор следует установить после текста “имя := ”.

Конструкторы массивов

Создание массивов типа Matrix

Функция Matrix(row, col, init, opts) создает двумерный массив типа Matrix, который является подтипом типа rtable. Эти массивы называются матрицами типа Matrix. Четвертый аргумент – последовательность опций, записываемых в виде “имя опции = значение” и задающих дополнительные свойства матриц. Все аргументы A необязательны и порядок их следования не фиксирован. Исключением являются параметры row и col. Задание числа строк row всегда должно предшествовать заданию числа столбцов col. В любом случае конкретная последовательность аргументов обязана однозначно задавать форму матрицы. Смысл аргументов следующий:

· row – фиксирует величину r, равную количеству строк матрицы. Аргумент row может быть задан натуральным числом r, или диапазоном 1..r;

· col – фиксирует величину c, равную количеству столбцов матрицы. Аргумент col может быть задан натуральным числом c или диапазоном 1..c. Если аргумент row задан, а аргумент col – нет, то по умолчанию col = row;

· init – задает инициализатор элементов матрицы в виде процедуры с двумя параметрами, алгебраического выражения, вычисляемого как процедура с двумя параметрами, списка, списка списков, множества уравнений в форме {(индекс, индекс) = значение, …} или в виде объектов типа vector, matrix, array, Vector, Matrix, Array. Если параметры row и col не заданы, то форма матрицы и ее элементы определяются аргументами init, sh, … Число строк и столбцов матрицы, задаваемых по row и col не должно быть меньше соответствующих значений, определяемых по init. При этом все или некоторые элементы матрицы формируются по init, а ее неопределенные элементы полагаются равными или нулю, или явно заданному значению из опции fill (см. ниже). По умолчанию вектором инициализируются все или некоторые элементы первого столбца или первой строки матрицы. Для того чтобы элементы вектора располагались по диагонали, необходимо установить опцию shape в значение diagonal.

В Matrix допустимы следующие опции opts:

· readonly = lo. Опция readonly (только для чтения) значением lo определяет возможность модификации матрицы. При lo = true матрицу можно изменять, а при lo = false – нет;

· symbol = sy. При отсутствии инициализатора init опция symbol значением sy задает символьное имя элементов матрицы. При наличии init опция symbol игнорируется;

· shape = sh. Опция shape (форма) значением sh указывает имя индексатора, то есть встроенной или пользовательской индексирующей функции (см. indexing functions). Индексаторы определяют структуру массива и возможность доступа к тем или иным его элементам. Например, если матрица a определена индексатором как верхняя треугольная (triangular[upper]), то присваивание значений ее элементам допустимо лишь тогда, когда они расположены в верхней треугольной части a. Остальные элементы a по умолчанию инициализируются нулями. Другой пример, если матрица определена как симметрическая (symmetric), то, присваивая значение какому-либо ее элементу, мы автоматически инициализируем (или переопределяем) тем же значением и симметричный ему элемент. По умолчанию опция shape отсутствует. Допускается наличие нескольких индексирующих функций. В этом случае они должны быть заданы списком. Опции shape, scan и storage взаимосвязаны. Имена и назначение встроенных индексирующих функций таковы:

o zero – задание нулевой матрицы. Все элементы матрицы полагаются равными 0;

o constant[c] – задание константной матрицы. Все элементы матрицы полагаются одному и тому же значению c;

o identity – задание единичной матрицы. Элементы главной диагонали матрицы полагаются равными единице, а остальные элементы – нулю;

o scalar[c] – задание скалярной диагональной матрицы. Элементы главной диагонали матрицы полагаются равными с, а остальные элементы – нулю;

o diagonal – задание диагональной матрицы. Элементы главной диагонали матрицы инициализируются в соответствии с аргументом init, а остальные элементы – нулями;

o triangular[upper] – задание верхней треугольной матрицы. Элементы матрицы, расположенные на главной диагонали и выше или правее нее, инициализируются обычным способом, а остальные элементы полагаются равными нулю. Значения triangular[upper] и triangular действуют одинаково;

o triangular[upper, unit] – задание верхней треугольной матрицы с единицами на главной диагонали. Данное значение действует так же, как и triangular[upper], за тем исключением, что здесь элементы главной диагонали инициализируются единицами;

o triangular[lower] – задание нижней треугольной матрицы. Элементы матрицы, расположенные на главной диагонали и ниже или левее нее, инициализируются обычным способом, а остальные элементы полагаются равными нулю;

o triangular[lower, unit] – задание нижней треугольной матрицы с единицами на главной диагонали. Данное значение действует так же, как и triangular[lower], за тем исключением, что здесь элементы главной диагонали инициализируются единицами;

o Hessenberg[upper] – задание верхней матрицы Хессенберга. Диагональ матрицы, расположенную сразу под главной диагональю, назовем поддиагональю. В верхней матрице Хессенберга элементы, расположенные на поддиагонали и выше или правее нее, инициализируются обычным способом, а остальные элементы полагаются равными нулю. Значения Hessenberg[upper] и Hessenberg действуют одинаково;

o Hessenberg[lower] – задание нижней матрицы Хессенберга. Диагональ матрицы, расположенную сразу над главной диагональю, назовем наддиагональю. В нижней матрице Хессенберга элементы, расположенные на наддиагонали и ниже или левее нее, инициализируются обычным способом, а остальные элементы полагаются равными нулю;

o band[b1, b2] – задание ленточной матрицы. В ленточной матрице элементы ее главной диагонали матрицы, b1 последовательных поддиагоналей и b2 последовательных наддиагоналей инициализируются обычным способом, а остальные элементы полагаются равными нулю. Записи band[b] и band[b, b] равносильны;

o symmetric – задание квадратной симметрической матрицы m. Элементы нижней треугольной матрицы в m инициализируется обычным образом, а элементы m[j, i] полагаются равными m[i, j] (i > j);

o antisymmetric (или skewsymmetric) – задание квадратной кососимметрической матрицы m. Элементы нижней треугольной матрицы в m инициализируется обычным образом, а элементы m[j, i] полагаются равными -m[i, j] (i > j);

o hermitian – задание квадратной эрмитовой матрицы m. Элементы m[i, j] (i > j), расположенные ниже главной диагонали m, инициализируется обычным образом. Элементы m[j, i], расположенные выше главной диагонали, полагаются равными комплексно-сопряженному для m[i, j] (i > j) значению. Инициализация элементов главной диагонали вещественными значениями проводится обычным образом, а вместо комплексных значений используются нули;

o antihermitian (или skewhermitian) – задание квадратной косоэрмитовой матрицы m. Элементы m[i, j] (i > j), расположенные ниже главной диагонали m, инициализируется обычным образом. Элементы m[j, i], расположенные выше главной диагонали, полагаются равными комплексно-сопряженному для -m[i, j] (i > j) значению. Инициализация элементов главной диагонали значениями с нулевой вещественной частью проводится обычным образом, а вместо других значений используются нули;

· scan = sc. Опция scan значениями sc Î {name, list} указывают структуру или порядок интерпретации инициализируемых по init элементов создаваемой матрицы. Подчеркнем, что в данном случае init может быть только вложенным списком. Опции scan, shape и storage взаимосвязаны. Возможные значения name таковы:

o [rectangular] или [rectangular, a], где a Î {rows, columns};

o [triangular[b], a], где b Î {upper, lower}, a Î {rows, columns};

o [Hessenberg[b], a], где b Î {upper, lower}, a Î {rows, columns};

o [band[b1, b2], d], где d Î {rows, columns, diagonals}. Значения band[b, b] и band[b] действуют одинаково. Значения band[0] и diagonal так же действуют одинаково;

· storage = st. Опция storage значением st задает режим связывания физической памяти для хранения элементов создаваемой матрицы. Опции storage, scan и shape взаимосвязаны. Возможные значения st:

o rectangular;

o triangular[a] или triangular[a, strict], где a Î {upper, lower};

o Hessenberg[a], где a Î {upper, lower};

o band[b1, b2]. Значения band[b, b] и band[b] действуют одинаково;

o diagonal; empty; sparse; sparse[b], где b Î {upper, lower};

· order = cf. Опция order значением cf фиксирует внутренний порядок элементов матрицы. При cf = C_order элементы матрицы загружаются в память по строкам, а при cf = Fortran_order – по столбцам;

· datatype = ty. Опция datatype параметром ty фиксирует тип данных для инициализации элементов матрицы. Возможные значения ty – любой Maple-тип, anything (любой, без ограничений), integer[n] (n = 1, 2, 4, 8), float[m] (m = 4, 8) и complex[k] (k = 8), где n, m и k – количество байтов памяти, отводимых под один элемент;

· fill = val. Опция fill параметром val устанавливается значение для всех неинициализированных элементов матрицы;

· attributes = list. Опция attributes элементами списка list задает атрибуты матрицы, специфицирующие ее дополнительные математические свойства.

Если размер созданной матрицы по каждому измерению не превосходит 10, то при выводе индицируется сама матрица, в противном случае – описание ее структуры. Двойной щелчок левой кнопкой мыши по матрице или по ее описанию открывает массив в обозревателе Browse Matrix. Здесь его можно просмотреть и, при необходимости, отредактировать.

Примеры 2. Здесь демонстрируются различные методы инициализации массивов типа Matrix. В последнем из примеров массив можно просматривать и редактировать только в обозревателе Browse Matrix.

>	Matrix(2), Matrix(2, 3), Matrix(2, 3, fill = 9);	{¿}
>	li := [[1, 4], [7]]:	{Shift+¿}
	Matrix(1..2, li), Matrix(1..2, 1..3, li);	{¿}
>	Matrix(2, 3, li, fill = a);	{¿}
>	Matrix(), Matrix([[2, 5, 7, bb], [0, dd, 5, 3]]);	{¿}
>	Matrix(2, 3, 5), Matrix(2, 3, (i, j) -> i+j^2);	{¿}
>	m := Matrix(2, 3, {(1, 1) = 2, (2, 1) = 3, (2, 2) = 6});	{¿}
>	Matrix(2, 4, m), Matrix(3, m);	{¿}
>	ve := Vector[row]([1, 2]);	{¿}
>	Matrix(2, ve), Matrix(2, ve, shape = diagonal);	{¿}
>	li := [[1, 2, 3, 4, 5, a], [0, 9, 8, 7, 6, 5, 4, 3, 2, 1, b]]:	{Shift+¿}
	ma := Matrix(li);	{¿}

Примеры 3. Действие различных аргументов функции Matrix при инициализации массивов.

>	a := Matrix(2, 3, h): # h = init	{Shift+¿}
	b := Matrix(2, 3, symbol = h): a, b;	{¿}
>	a[1, 2], b[1, 2];	{¿}
>	a := Matrix(2, 3, storage = triangular[upper, strict], fill = x):	{Shift+¿}
	b := Matrix(2, 3, storage = triangular[upper], fill = x): a, b;	{¿}
>	li := [[1, 2, 7], [4, 9, 8], [5]]:	{Shift+¿}
	a := Matrix(li, scan = [triangular[upper], rows]):	{Shift+¿}
	b := Matrix(li, scan = [triangular[lower], columns]): a, b;	{¿}
>	a := Matrix(li, shape = triangular[upper]):	{Shift+¿}
	b := Matrix(li, shape = triangular[lower]): a, b;	{¿}

Примеры 4. Действие опции shape при инициализации массивов типа Matrix.

>	v := Matrix(2): w := Matrix(2, shape = zero): v, w;	{¿}
>	v[1, 1] := 5;	{¿}
>	w[1, 1] := 5;	{¿}
>	v := Matrix(1..2, 1..3, shape = constant[b]):	{Shift+¿}
	w := Matrix(1..2, 1..3, shape = identity):	{Shift+¿}
	u := Matrix(1..2, 1..3, shape = scalar[bb]): v, w, u;	{¿}
>	di := 1..2, 1..3:	{Shift+¿}
	v := Matrix(di, <1, 5>, shape = diagonal):	{Shift+¿}
	w := Matrix(di, [[xx, 3, 5], [6, 7, 8]], shape = diagonal):	{Shift+¿}
	v, w;	{¿}
>	di := 1..2, 1..3: li := [[1, 2, 3], [4, 5, 6]]:	{Shift+¿}
	u := Matrix(di, li, shape = triangular[upper]):	{Shift+¿}
	v := Matrix(di, li, shape = triangular[lower]):	{Shift+¿}
	w := Matrix(di, li, shape = triangular[upper, unit]):	{Shift+¿}
	x := Matrix(di, li, shape = triangular[lower, unit]):	{Shift+¿}
	u, v, w, x;	{¿}
>	li := [[1, 2, 3, 4], [5, 6, 7, 8], [2, 1, 2, 5], [9, 5, 6, 7]]:	{Shift+¿}
	h1 := Matrix(li, shape = Hessenberg[upper]):	{Shift+¿}
	h2 := Matrix(li, shape = Hessenberg[lower]):	{Shift+¿}
	h1, h2;	{¿}
>	restart: li := [[w, w, w], [x, x, x], [z, z]]:	{Shift+¿}
	m1:= Matrix(li, shape = band[1, 2]):	{Shift+¿}
	m2 := Matrix(li, shape = band[1, 2], scan = band[1, 2]):	{Shift+¿}
	m3 := Matrix(li, shape = band[2, 1]): m1, m2, m3;	{¿}
>	li := [[1, 2, 3], [5, 6, 7], [6, 8, 9]]:	{Shift+¿}
	m1:= Matrix(li, shape = symmetric):	{Shift+¿}
	m2:= Matrix(li, shape = antisymmetric): m1, m2;	{¿}
>	li := [[1+I, I, 3], [5-I, 6, 7+3*I], [6-I, 8+I, 5*I]]:	{Shift+¿}
	m1 := Matrix(li, shape = hermitian):	{Shift+¿}
	m2 := Matrix(li, shape = antihermitian): m1, m2;	{¿}

Получение и установка опций матрицы

Функция MatrixOptions(m) для матрицы m типа Matrix возвращает последовательность уравнений вида opt_k = v_k, (k = 1, 2, …, n), где opt_k – имена опций m, а v_k – их значения.

Функция MatrixOptions(m, opt₁, opt₂, …, opt_n) для матрицы m типа Matrix возвращает последовательность значений v_k (k = 1, 2, …, n), соответствующих опциям с именами opt_k.

Функция MatrixOptions(m, opt₁ = v₁, opt₂ = v₂, …, opt_n = v_n) для матрицы m типа Matrix устанавливает для опций opt_k (k = 1, 2, …, n) значения v_k .

Имеет ли матрица заданную форму?

Функция IsMatrixShape(m, shape) возвращает логическое значение true, если матрица m типа Matrix имеет форму shape, и false – в противном случае. Возможные значения для shape таковы: zero, identity, scalar, scalar[c], diagonal, constant, constant[c], band[b1, b2], band[b], symmetric, antisymmetric (или skewsymmetric), hermitian, antihermitian (или skewhermitian), triangular (или triangular[upper]), triangular[lower], triangular[upper, unit], triangular[lower, unit], Hessenberg[lower], Hessenberg (или Hessenberg[upper]). Ранее, при описании опции shape функции Matrix, уже рассказывалось о том, что представляют собой эти формы. Кроме того, shape может быть формой, определенной пользователем.

Примеры 5. Функции MatrixOptions и IsMatrixShape.

>	li := [[a, 3, 5], [6, 8, b]]: di := 1..2, 1..3:	{Shift+¿}
	v := Matrix(di, <3, 5>, shape = diagonal):	{Shift+¿}
	w := Matrix(di, li, shape = triangular[upper]):	{Shift+¿}
	v, w;	{¿}
>	MatrixOptions(v);	{¿}
>	MatrixOptions(w, shape);	{¿}
>	IsMatrixShape(v, diagonal), IsMatrixShape(w, diagonal);	{¿}

Создание массивов типа Vector

Функция Vector[ori](le, init, opts) создает одномерный массив типа Vector, который является подтипом типа rtable. Эти массивы называются векторами типа Vector. Вместе с матрицами типа Matrix они являются основными структурами данных, которыми оперируют многочисленные функции пакета расширений LinearAlgebra. Третий аргумент – последовательность опций, определяющих дополнительные свойства массивов. Все аргументы необязательны, порядок их следования не фиксирован. Смысл спецификатора ori и аргументов следующий:

· ori – определяет направление вектора. При ori = row создается вектор-строка, а при ori = column – вектор-столбец (см. опцию orientation);

· le – фиксирует величину, равную количеству компонентов вектора, то есть его длине. Аргумент может быть задан натуральным числом n или диапазоном 1..n;

· init – задает инициализатор элементов вектора в виде процедуры с одним параметром, алгебраического выражения, вычисляемого как процедура с одним параметром, списка, списка списков, множества уравнений в форме {индекс = значение, …} или в виде объектов типа vector, array, table, Vector, Array. Если параметр le не задан, то длина вектора и его элементы определяются аргументами init, sh, … Число элементов, задаваемых по le не должно быть меньше соответствующего значения, определяемого по init. При этом все или некоторые элементы вектора формируются по init, а его неопределенные элементы полагаются равными или нулю, или явно заданному значению из опции fill (см. ниже);

В Vector[ori](le, init, opts) допустимы следующие опции opts:

· readonly = lo. Опция readonly значением lo определяет возможность модификации вектора. При lo = true вектор можно изменять, а при lo = false – нет;

· symbol = sy. При отсутствии инициализатора init опция symbol значением sy задает символьное имя элементов вектора. При наличии init опция symbol игнорируется;

· shape = sh. Опция shape значением sh указывает имя встроенной или пользовательской индексирующей функции (см. indexing functions), определяющей структуру вектора. По умолчанию опция shape отсутствует. Имена и назначение встроенных индексирующих функций таковы:

o zero – задание нулевого вектора. Все элементы вектора полагаются равными 0;

o constant[c] – задание константного вектора. Все элементы вектора полагаются одному и тому же значению c;

o unit[j] – задание единичного вектора. Элемент вектора с индексом j полагается равным единице, а остальные элементы – нулю;

o scalar[j, c] – задание скалярного вектора. Элемент вектора с индексом j полагается равным c, а остальные элементы – нулю;

· storage = st. Опция storage значением st задает режим связывания физической памяти для хранения компонентов создаваемого вектора;

· datatype = ty. Опция datatype параметром ty фиксирует тип данных для инициализации элементов вектора. Возможные значения ty – любой Maple-тип, anything (любой, без ограничений), integer[n] (n = 1, 2, 4, 8), float[m] (m = 4, 8) и complex[k] (k = 8), где n, m и k – количество байтов памяти, отводимых под один элемент;

· fill = val. Опция fill параметром val устанавливается значение для всех неинициализированных компонентов вектора;

· attributes = list. Опция attributes элементами списка list задает атрибуты вектора, специфицирующие его дополнительные математические свойства.

· orientation = ori. Опция orientation значением ori задает направление вектора. При ori = row создается вектор-строка, а при ori = column – вектор-столбец. Данная опция действует аналогично спецификатору ori.

Если размер созданного вектора не превосходит 10, то при выводе индицируется сам вектор, в противном случае – описание его структуры. Двойной щелчок левой кнопкой мыши по вектору или его описанию открывает массив в обозревателе Browse Matrix. Здесь его можно просмотреть и, при необходимости, отредактировать.

Примеры 6. Здесь демонстрируются различные методы инициализации массивов типа Vector. В последнем из примеров массив можно просматривать и редактировать только в обозревателе Browse Matrix.

>	Vector(3), Vector(3, fill = 9), Vector(1..3, [1, 4, 9]);	{¿}
>	Vector[row](3), Vector[row](3, fill = 9);	{¿}
>	Vector[row](3, 4), Vector[row](3, x+y);	{¿}
>	Vector[row]([1, 7, 8]), Vector[row](3, symbol = t);	{¿}
>	h := Vector[row](3), Vector();	{¿}
>	Vector[row](5, i -> i^3);	{¿}
>	m := Vector[row](7, {1 = 1, 2 = 8, 3 = 27, 4 = 64, 5 = 125});	{¿}
>	Vector[row](9, m);	{¿}
>	Vector(10, m, orientation = row, fill = a);	{¿}
>	Vector[row](7, [[1, 7, 8], [1, 3]]);	{¿}
>	a := vector([q, w, 5]): a := Vector(a): t1 := type(a, Vector):	{Shift+¿}
	c := array(1..3, [q, w, 5]): c := Vector(c): t2 := type(c, Vector):	{Shift+¿}
	g := table([q, w, 5]): g := Vector(3, g): t3 := type(g,Vector):	{Shift+¿}
	e := Vector(3, [q, w, 5]): e := Vector(e): t4 := type(e, Vector):	{Shift+¿}
	f := Array(1..3, [q, w, 5]): f := Vector(f): t5:= type(f, Vector):	{Shift+¿}
	t1, t2, t3, t4, t5;	{¿}
>	b := matrix(1, 3, [q, w, 5]): b := Vector(b);	{¿}
>	d := Matrix(1, 3, [q, w, 5]): d := Vector(d);	{¿}
>	ma := Vector([0, 9, 8, 7, 6, 5, 4, 3, 2, 1, b]);	{¿}

Примеры 7. Здесь демонстрируются действие опции shape при инициализации массивов типа Vector, а также применение групповой операции map к элементам массивов.

>	restart:	{¿}
>	Vector[row](5), Vector[row](5, shape = zero);	{¿}
>	Vector[row](5, 7), Vector[row](5, shape = constant[7]);	{¿}
>	Vector[row](5, shape = unit[3]);	{¿}
>	Vector[row](5, shape = scalar[3, 7]);	{¿}
>	qw := Vector[row](1..3, [t, (t+1)^2, (t+1)^3-t^3-1]):	{Shift+¿}
	as := map(diff, qw, t);	{¿}
>	map(simplify, as);	{¿}

Получение и установка опций вектора

Функция VectorOptions(m) для вектора m типа Vector возвращает последовательность уравнений вида optk = vk, (k = 1, 2, …, n), где optk – имена опций m, а vk – их значения.

Функция VectorOptions(m, opt1, opt2, …, optn) для вектора m типа Vector возвращает последовательность значений vk (k = 1, 2, …, n), соответствующих опциям с именами optk.

Функция VectorOptions(m, opt1 = v1, opt2 = v2, …, optn = vn) для вектора m типа Vector устанавливает для опций optk (k = 1, 2, …, n) значения vk .

Имеет ли вектор заданную форму?

Функция IsVectorShape(m, shape) возвращает логическое значение true, если вектор m типа Vector имеет форму shape, и false – в противном случае. Возможные значения для shape таковы: zero, unit[j], scalar[j, c], constant[c]. Ранее, при описании опции shape функции Vector, уже рассказывалось о том, что представляют собой эти формы. Кроме того, shape может быть формой, определенной пользователем.

Создание массивов типа Array

Функция Array(dims, init, ifuns, opts) создает массив типа Array, который является подтипом типа rtable. Четвертый аргумент opts в A – последовательность опций, задающих дополнительные свойства массивов. Каждый из аргументов A необязателен, а смысл их следующий:

· dims – определяет размерность n (от 1 до 63) и размеры массива по каждому измерению. Параметр dims есть последовательность из n диапазонов вида a_i..b_i (i = 1, 2, …, n), где a_i, b_i – целые числа, a_i £ b_i, b_i–a_i+1 – размер массива по i-му измерению. Допускается рассмотрение и нуль-мерных массивов, задаваемых определениями вида Array(1..0) или Array(7);

· init – задает инициализатор элементов массива в виде процедуры, множества уравнений вида {(последовательность индексов) = значение, …}, простого или вложенного списка, алгебраического выражения с числовым значением или объектов типа table, array, matrix, vector, Array, Matrix, Vector. Например, процедура может быть задана в виде (i, j, k) -> i^2+j^2+k^2;

· ifuns – специфицирует последовательность индексаторов, являющихся именами специальных пользовательских или встроенных процедур (см. indexing functions). Индексаторы определяют структуру массива и возможность доступа к тем или иным его элементам. Имена и назначение встроенных индексирующих функций таковы: zero, unit[j], scalar[j, a], scalar[n], identity, constant[a], diagonal, band[b1, b2], triangular[upper], triangular[lower], triangular[upper, unit], triangular[lower, unit], Hessenberg[upper], Hessenberg[lower], symmetric, antisymmetric, hermitian, antihermitian;

В Array(dims, init, ifuns, opts) допустимы следующие опции opts:

· datatype = ty. Опция datatype значением ty фиксирует тип данных для инициализации элементов массива. Возможные значения ty – любой Maple-тип, anything (любой, без ограничений), integer[n] (n = 1, 2, 4, 8), float[m] (m = 4, 8) и complex[k] (k = 8), где n, m и k – количество байтов памяти, отводимых под один элемент;

· storage = st. Опция storage значением st задает режим связывания физической памяти для хранения элементов создаваемого массива (см. storage mode). Возможные значения st:

o rectangular;

o triangular[a] или triangular[a, strict], где a Î {upper, lower};

o Hessenberg[a], где a Î {upper, lower};

o band[b1, b2]. Значения band[b, b] и band[b] действуют одинаково;

o diagonal; scalar; empty; sparse; sparse[b], где b Î {upper, lower};

· order = cf. Опция order используется только для матриц и значением cf Î {C_order, Fortran_order} определяет порядок загрузки их элементов в память. При cf = C_order элементы матрицы загружаются по строкам, а при cf = Fortran_order – по столбцам;

· readonly = lo. Опция readonly значением lo Î {true, false} устанавливает возможность модификации массива. При lo = true массив можно изменять, а при lo = false – нет;

· attributes = list. Опция attributes элементами списка list задает атрибуты массива, то есть его дополнительные математические свойства (см. attributes);

· transpose = lo. Опция transpose значением lo Î {true, false} задает способ формирования массива по инициализирующему списку. Например, для матрицы при lo = false из последовательных элементов k-го внутреннего списка формируется k-я строка, а при lo = true – k-й столбец;

· fill = expr. Опция fill выражением expr формирует значения для всех неинициализированных элементов массива.

Примеры 8. Различные методы инициализации массивов типа Array.

>	a := Array(1..2, 1..3): b := Array(1..2, 1..3, 7): a, b;	{¿}
>	type(b, rtable), type(b, Array), type(b, Matrix);	{¿}
>	subtype(Array, rtable), subtype(rtable, Array);	{¿}
>	m:= Array(1..2, 1..3, (i, j) -> i+j^2);	{¿}
>	a := Array(1..2, 1..3, [[2, 5, 10], [3, 6, 11]]): # a = m	{¿}
>	b := Array([[2, 5, 10], [3, 6, 11]]): # b = m	{¿}
>	c := Array(1..2, 1..3,	{Shift+¿}
	{(1, 1) = 2, (1, 2) = 5, (1, 3) = 10,	{Shift+¿}
	(2, 1) = 3, (2, 2) = 6, (2, 3) = 11}): # c = m	{¿}
>	md := <<2, 3> | <3, 4> | <4, 5>>:	{Shift+¿}
	d := Array(mm): # d = m	{¿}
>	me := matrix([[2, 5, 10], [3, 6, 11]]) # или array	{Shift+¿}
	e := Array(me) # e = m	{¿}
>	mf := table([x1, x2, x3, x4, x5]):	{Shift+¿}
	f := Array(1..5, mf); type(f, Array);	{¿}

Если размерность созданного массива не превосходит двух и размер по каждому измерению не превосходит 10, то при выводе индицируется сам массив, в противном случае – описание его структуры. Двойной щелчок левой кнопкой мыши по массиву или его описанию открывает массив в обозревателе Browse Matrix. Здесь его можно просмотреть и, при необходимости, отредактировать. Двойной щелчок левой кнопкой мыши по описанию массива m размером n1´n2´n3´…´nm (m > 2) открывает в обозревателе одну из его страниц (срезов) – матрицу, соответствующую элементам с индексами m[i, j, 1, 1, …, 1] (i = 1, 2, …, n1; j = 1, 2, …, n2). Выведенная страница может быть просмотрена и отредактирована. Фиксируя в обозревателе на закладке Options в столбце Fixed пары измерений и позиции элементов в них, можно просмотреть и отредактировать любые другие страницы массива m (см. рис. 2). Например, в четырехмерном массиве m размером n1´n2´n3´n4 = 2´3´4´5 первоначально в обозревателе открывается страница

размером 2´3, а всего в m имеется n1n2+n1n3+n1n4+n2n3+n2n4+n3n4 = 71 страница размерами 2´3, 2´4, 2´5, 3´4, 3´5 и 4´5..

Примеры 9. Здесь демонстрируются возможные типы вывода сформированного массива и его открытие в обозревателе Browse Matrix. Двумерный массив ma и четырехмерный массив mm откройте в браузере двойным щелчком левой кнопки мыши по структурам ma и mm.

>	li := [[1, 2, 3], [7, 7, 9, 9, 6, 8]]:	{Shift+¿}
>	m := Array(1..3, 1..10, li, datatype = integer);	{¿}
>	m[1, 10] := 99.5;	{¿}
>	ma := Array(1..3, 1..12, li, datatype = integer);	{¿}
>	mm := Array([[[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [14, 15, 16]]],	{Shift+¿}
	[[[21, 22, 23], [24, 25, 26]], [[41, 42, 43], [34, 35, 36]]]]);	{¿}

Получение характеристик массивов типа Array

Функция ArrayDims(m) возвращает последовательность диапазонов ak..bk (ak £ bk k = 1, 2, …, n) индексов массива m по соответствующим измерениям. Количество n таких диапазонов равно размерности массива m, а величина (b1–a1+1)´(b2–a2+1)´…´(bn–an+1) – его размеру. Значение, получаемое по A, равно величине op(2, m).

Функция ArrayNumDims(m) возвращает размерность массива m. Значение, получаемое по B, равно величине nops([ArrayDims(m)]).

Функция ArrayElems(m) возвращает элементы массива m в виде множества уравнений {(индексы) = значение, …}. При этом выводятся лишь явно специфицированные элементы m. Значение, получаемое по C, равно величине op(3, m).

Функция ArrayNumElems(m, tip) без аргумента tip возвращает общее количество действительно загруженных в память элементов массива m. Параметр tip может принимать значения All, Stored, NonZero, NonZeroStored, Allocated и Bytes и предписывает вывод количества элементов m конкретного типа или памяти в байтах (Bytes), используемой под элементы.

Функция ArrayIndFns(m) возвращает последовательность индексирующих функций, если они есть. Значение, получаемое по E, равно величине op(1, m).

Функция ArrayOptions(m, opts). Здесь необязательные аргументы opts – это последовательность имен опций массива m или последовательность уравнений вида “имя опции = значение”. Если в F аргументы opts отсутствуют, то возвращается последовательность всех опций и их значений массива m. Если в F аргумент opts есть последовательность имен конкретных опций, то возвращается последовательность соответствующих им значений. Если в F аргумент opts есть последовательность уравнений вида “имя опции = значение”, то соответствующие опции модифицируются. Это возможно лишь для опций order, readonly и attribute.

Примеры 10. Функции получения характеристик массивов типа Array.

>	h := Array(1..2, -2..2, [[1, 0, 0, 4, 0], [0, 7, 8, 9, 0]]):	{Shift+¿}
	ArrayDims(h);	{¿}
>	ArrayNumDims(h);	{¿}
>	ArrayElems(h);	{¿}
>	opti := [All, Stored, NonZero, NonZeroStored, Bytes]:	{Shift+¿}
	s := NULL:	{Shift+¿}
	for j from 1 to nops(opti) do	{Shift+¿}
	s := s, ArrayNumElems(h, opti[j])	{Shift+¿}
	end do: s;	{¿}
>	ArrayOptions(h);	{¿}
>	ArrayOptions(h, datatype, storage);	{¿}

Генераторы массивов

Если необходим массив, например, для отладки и тестирования написанной программы, то создать его можно конструкторами Matrix, Vector, … Но формирование массивов больших размеров этим способом обычно требует значительных временных ресурсов по вводу данных с клавиатуры. Быстрое создание массивов можно осуществлять с помощью специальных генераторов-функций, о которых и пойдет речь ниже. Эти функции возвращают числовые и нечисловые псевдослучайные матрицы (RandomMatrix, randmatrix) и псевдослучайные векторы (RandomVector, randvector). Кроме того, в этом же разделе рассмотрены вопросы генерирования псевдослучайных чисел (rand, _seed, randomize) и псевдослучайных многочленов (randpoly).

Генерирование псевдослучайных матриц типа Matrix

Функция RandomMatrix(r, c, opts) находится в пакете расширения LinearAlgebra. По A генерируется псевдослучайная матрица типа Matrix размером r´с, где r и c – целые неотрицательные числа, определяющие соответственно количество строк и количество столбцов матрицы. Все аргументы в A необязательны. При отсутствии аргументов и при r = c = 0 по A формируется пустая матрица. Если r и с не превосходят 10, то выводится сгенерированная матрица, в противном случае – описание ее структуры. Двойной щелчок левой кнопкой мыши по матрице или по ее описанию открывает массив в обозревателе Browse Matrix. Здесь его можно просмотреть и, при необходимости, отредактировать. Аргумент opts в A – последовательность опций, определяющих свойства матрицы. Ниже перечислены все допустимые опции и дано их описание:

· generator = f. Опция generator параметром f задает генератор значений для элементов матрицы. По умолчанию – это диапазон -99..99, то есть генерируются целые числа, равномерно распределенные на отрезке [-99, 99]. В общем случае f может быть:

o конкретным числом;

o диапазоном действительных чисел (например, 1..5);

o диапазоном целых чисел (например, 1..5. или 1.0..5);

o произвольной процедурой без аргументов. Пользовательские процедуры генерирования значений удобно создавать на основе встроенной процедуры rand(a..b) (см. пример ниже) ;

· density = p (0 £ p £ 1). Опция density (плотность) величиной p задает плотность формируемой матрицы m, то есть приближенное значение отношения количества ненулевых элементов m к общему количеству элементов m. На параметр p можно смотреть как на вероятность того, что очередное сгенерированное значение присваивается конкретному элементу матрицы;

· outputoptions = li. Опция outputoptions элементами списка li задает выводные опции матрицы, определяющие ее структуру (shape = sh), права доступа (readonly = lo), тип данных (datatype = ty) и атрибуты (attributes = list). Действие этих опций аналогично действию соответствующих опций конструктора Matrix. Например, структура генерируемой матрицы задается значением sh опции shape, где sh может быть: zero, constant[c], identity, scalar[c], diagonal, triangular[upper], triangular[lower], band[b1, b2], symmetric и т. д.

Примеры 11. Генерирование псевдослучайных матриц типа Matrix.

>	restart: with(LinearAlgebra):	{¿}
>	a := RandomMatrix(2, 3, generator = 5):	{Shift+¿}
	b := RandomMatrix(2, 3, density = 0.5, generator = 1):	{Shift+¿}
	c := RandomMatrix(2, 3, generator = 1..5):	{Shift+¿}
	a, b, c;	{¿}
>	map(whattype, [a, b, c]);	{¿}
>	RandomMatrix(2, 3, generator = 1..5.,	{Shift+¿}
	outputoptions = [datatype = float[4],	{Shift+¿}
	shape = triangular[upper]]):	{¿}
>	pr := proc()	{Shift+¿}
	local as, a, b, c, ot;	{Shift+¿}
	as := rand(1..3);	{Shift+¿}
	if as() = 1 then ot := a	{Shift+¿}
	elif as() = 2 then ot := b	{Shift+¿}
	else ot := c	{Shift+¿}
	end if; ot;	{Shift+¿}
	end proc:	{¿}
>	RandomMatrix(2, 5, generator = pr); whattype(%);	{¿}

Примеры 12. Действие опции shape при генерировании псевдослучайных матриц типа Matrix.

>	x := RandomMatrix(2, 3, generator = 1..5,	{Shift+¿}
	outputoptions = [shape = diagonal]):	{Shift+¿}
	y := RandomMatrix(2, 3, generator = 1..5,	{Shift+¿}
	outputoptions = [shape = triangular[lower]]):	{Shift+¿}
	z := RandomMatrix(2, 3, generator = 1..5,	{Shift+¿}
	outputoptions = [shape = band[0,1]]):	{Shift+¿}
	x, y, z;	{¿}
>	x := RandomMatrix(3, 3, generator = 1..5,	{Shift+¿}
	outputoptions = [shape = symmetric]):	{Shift+¿}
	y := RandomMatrix(3, 3, generator = 1..5,	{Shift+¿}
	outputoptions = [shape = antisymmetric]):	{Shift+¿}
	x, y;	{¿}

Генерирование псевдослучайных векторов типа Vector

Функция RandomVector[ori](le, opts) находится в пакете расширения LinearAlgebra. По A генерируется псевдослучайный вектор типа Vector длины le, где le – целое неотрицательное число. Все аргументы в A необязательны. При отсутствии аргументов и при le = 0 по A формируется пустой вектор. Если le не превосходят 10, то выводится сгенерированный вектор, в противном случае – описание его структуры. Двойной щелчок левой кнопкой мыши по вектору или по его описанию открывает массив в обозревателе Browse Matrix. Здесь его можно просмотреть и, при необходимости, отредактировать. Аргумент opts в A – последовательность опций, определяющих свойства вектора. Ниже дано описание спецификатора ori и всех допустимых опций функции A:

· ori – спецификатор направление вектора. При ori = row создается вектор-строка, а при ori = column – вектор-столбец;

· generator = f. Опция generator параметром f задает генератор значений для элементов вектора (см. эту же опцию у RandomMatrix);

· density = p (0 £ p £ 1). Опция density (плотность) величиной p задает плотность формируемого вектора v, то есть приближенное значение отношения количества ненулевых элементов v к общему количеству элементов v. На параметр p можно смотреть как на вероятность того, что очередное сгенерированное значение присваивается конкретному элементу вектора;

· outputoptions = li. Опция outputoptions элементами списка li задает выводные опции вектора, определяющие его структуру (shape = sh), права доступа (readonly = lo), тип данных (datatype = ty) и атрибуты (attributes = list). Действие этих опций аналогично действию соответствующих опций конструктора Vector.

Примеры 13. Генерирование псевдослучайных векторов типа Vector.

>	restart: with(LinearAlgebra):	{¿}
>	RandomVector[row](10);	{¿}
>	RandomVector[row](10, generator = 1..5);	{¿}
>	RandomVector[row](10, generator = 1..5, density = 0.5);	{¿}

Генерирование псевдослучайных чисел

Функция rand() генерирует псевдослучайное целое неотрицательное число из диапазона 1..999999999999 (при равномерном распределении).

Функция qw := rand(n..m), здесь n и m (n < m) выражения с целочисленными значениями. По B возвращается процедура qw, которую далее в форме qw() можно использовать для генерирования целых псевдослучайных чисел, равномерно распределенных в диапазоне n..m. Имя qw может быть иным.

Функция qw := rand(n) представляет собой сокращенную форму записи функции B для qw := rand(0, n–1).

Команда _seed := posint Значение системной переменной _seed используется для инициализации генератора псевдослучайных чисел любым целым положительным числом posint. Подобная инициализация фиксирует выдаваемую в дальнейшем последовательность псевдослучайных чисел. Это обстоятельство бывает полезным при отладке программ.

Функция randomize(posint) Выполнение равносильно присваиванию _seed = posint, где posint – целое неотрицательное число (см. D).

Функция randomize() Выполнение F равносильно присваиванию _seed = n, где n целое число, базирующееся на показаниях системных часов. Функция F предоставляет наиболее полезный и часто используемый способ инициализации системной переменной _seed.

Примеры 14. Здесь qw – процедура генерирования целого псевдослучайного числа из диапазона 1..9, rd – процедура генерирования последовательности из n целых псевдослучайных чисел из этого же диапазона.

>	qw := rand(1..9):	{¿}
>	rd := proc(n) local s, j; s := NULL:	{Shift+¿}
	for j from 1 to n do s := s, qw() end do: s;	{Shift+¿}
	end proc	{¿}
>	_seed := 71: rd(15);	{¿}
>	_seed := 73: rd(15);	{¿}
>	_seed := 71: rd(15);	{¿}

Генерирование псевдослучайных матриц типа matrix

Функция randmatrix(n, m, opts) находится в пакете расширения linalg и генерирует матрицу типа matrix размером n´m с n строками и m столбцами. Элементы матрицы являются псевдослучайными целыми числами из некоторого диапазона. Необязательные аргументы opts – опции. Они задаются именами и (или) уравнениями, определяют тип матрицы и могут быть такими: dense – обычная (плотная) матрица, sparse – разреженная матрица, symmetric – симметрическая квадратная матрица, antisymmetric – антисимметрическая квадратная матрица, unimodular – унимодулярная квадратная матрица (определитель равен ±1). Опция entries = g задает процедуру g генерирования элементов матрицы из некоторого числового диапазона. По умолчанию g = rand(-99..99), то есть элементы матрицы расположены в диапазоне -99..99.

Примеры 15. Генерирование псевдослучайных матриц типа matrix.

>	with(linalg, randmatrix):	{¿}
>	b := randmatrix(2, 3);	{¿}
>	b, eval(b), type(b, matrix), type(b, array);	{¿}
>	a := randmatrix(3, 3, symmetric):	{Shift+¿}
	b := randmatrix(3, 3, antisymmetric,	{Shift+¿}
	entries = rand(1..9)):	{Shift+¿}
	{eval(a), eval(b)};	{¿}
>	n := 4: m:=9:	{Shift+¿}
	A := randmatrix(n, n, entries = rand(1..m)):	{Shift+¿}
	B := convert(A, listlist);	{¿}
>	type(A, matrix), type(B, listlist);	{¿}

Генерирование псевдослучайных векторов типа vector

Функция randvector(n, entries = g) находится в пакете расширения linalg и генерирует вектор типа vector с n элементами, которые являются псевдослучайными целыми числами. Необязательный второй аргумент entries = g – является опцией и задает процедуру g генерирования элементов вектора из некоторого числового диапазона. По умолчанию g = rand(-99..99), то есть элементы вектора расположены в диапазоне -99..99.

Примеры 16. Генерирование псевдослучайных векторов типа vector.

>	a := linalg[randvector](5);	{¿}
>	a, eval(a), type(a, vector), type(a, array);	{¿}
>	linalg[randvector](5, entries = rand(3));	{¿}

Генерирование псевдослучайных многочленов

Генерирование плотного (обычного) многочлена означает, что коэффициенты формируются для каждого его возможного члена. Это не исключает получение конкретного коэффициента, равного нулю. Генерирование разреженного многочлена означает, что коэффициенты формируются лишь для некоторых его членов, а остальные коэффициенты полагаются равными нулю.

Функция randpoly(x, opts) генерирует и возвращает многочлен от одной переменной или выражения x. По умолчанию формируется разреженный многочлен степени 5 с псевдослучайными целыми коэффициентами из диапазона -99..99.

Функция randpoly([x, y, …], opts) по умолчанию генерирует и возвращает многочлен от конечного числа переменных или выражений x, y, … По умолчанию формируется разреженный многочлен степени 5 (наибольшая, суммарная) с псевдослучайными целыми коэффициентами из диапазона -99..99. Список в B можно заменить множеством.

Необязательные аргументы opts в A и B – это опции. Они задаются именами и (или) уравнениями и могут быть такими:

· опция degree = m, где m – целое число, задает степень многочлена;

· опция coeffs = g задает процедуру g генерирования коэффициентов многочлена из некоторого числового диапазона. По умолчанию g = rand(-99..99);

· опция expons = f задает процедуру f генерирования степеней неизвестных (выражений) из некоторого числового диапазона. По умолчанию f = rand(6);

· опция terms = n, где n – целое число, задает количество генерируемых термов многочлена;

· опция dense назначает генерирование плотного многочлена;

· опция sparse задает генерирование разреженного многочлена;

· опция homogeneous определяет генерирование гомогенного многочлена, то есть многочлена, в котором все члены имеют одну и ту же (суммарную) степень;

Примеры 17. Генерирование псевдослучайного многочлена.

>	randpoly(t, degree = 7);	{¿}
>	randpoly(t, degree = 7, dense);	{¿}
>	randpoly(t, degree = 7, terms =4);	{¿}
>	randpoly([x, y]);	{¿}
>	randpoly([x, y, z], homogeneous, degree = 3);	{¿}
>	randpoly([sin(x), cos(x)], expons = rand(3));	{¿}

Дополнительные возможности для работы со случайными Maple-объектами предоставляются командами пакетов RandomTools и stats.

Примеры 18. Запись массивов произвольных типов и размерностей в файл и считывание их из файла.

>	aa := Vector[row]([1, def, 5]):	{Shift+¿}
	bb := Matrix([[1], [2, 3, x+y]]):	{Shift+¿}
	se := {(1, 1, 1) = y, (1, 3, 2) = 20, (2, 2, 3) = 30, (2, 4, 1) = z}:	{Shift+¿}
	cc := Array(1..2, 1..4, 1..3, se):	{Shift+¿}
	aa, bb, cc;	{¿}
>	save aa, bb, cc, "e:\\massi.txt";	{¿}
>	read "e:\\massi.txt";	{¿}
>	type(aa, rtable), type(bb, rtable), type(cc, rtable);	{¿}
>	type(aa, Vector), type(bb, Matrix), type(cc, Array);	{¿}
>	whattype(aa), whattype(bb), whattype(cc);	{¿}
>	a := vector([1, 2]): b := matrix([[x-y], [x+y, x*y]]):	{Shift+¿}
	c := array(1..3, 1..2, 1..4):	{Shift+¿}
	eval(a), eval(b), evalm(b);	{¿}
>	save a, b, c, "e:\\ab.ttt";	{Shift+¿}
	read "e:\\ab.ttt";	{¿}
>	type(a, vector), type(b, matrix);	{¿}
>	type(a, array), type(b, array), type(c, array);	{¿}
>	whattype(eval(a)), whattype(eval(b)), whattype(eval(c));	{¿}
>	ta := table([one = eins, two = zwei, three = drei]):	{Shift+¿}
	save ta, "e:\\ta.txt";	{Shift+¿}
	read "e:\\ta.txt";	{¿}
>	ta[two], whattype(eval(ta)), type(eval(ta), array);	{¿}

Пример 19. По приведенному ниже фрагменту программы для случайно сгенерированной матрицы m размером k´k и действительными элементами из промежутка [0, 1) вычисляются собственные значения l и формируется их список li. Затем по li с помощью процедуры gra строится точечный график собственных значений m. Далее, по той же процедуре gra выводится график, построенный по точкам abs(l)+0*I. Наконец, последний график построен по процедурам gra и gram. Он отличается от первого графика лишь тем, что выведенные точки дополнительно соединяются отрезками прямых линий с началом координат. Процедура gra для вывода точек использует функцию complexplot пакета расширений plots, а процедура gram для вывода отрезков линий использует функцию polygon пакета расширений plottools. Просмотрев соответствующие графики и продолжив эксперименты с квадратными матрицами других размерностей, можно было бы высказать достаточно интересные гипотезы относительно расположения их собственных значений. Например, такую: “Любая квадратная матрица с неотрицательными элементами имеет положительное собственное значение, которое не меньше модулей других ее собственных значений”. И это утверждение действительно справедливо (теорема Фробениуса–Перона).

>	restart: with(LinearAlgebra):	{¿}
>	k := 8: m := RandomMatrix(k, generator = 0 .. 1.):	{Shift+¿}
	li := Eigenvalues(m):	{Shift+¿}
	li := convert(li, list):	{¿}
>	with(plots):	{¿}
>	gra := proc(x)	{Shift+¿}
	complexplot(x, style = point, color = black,	{Shift+¿}
	symbol = circle, symbolsize = 10, thickness =2,	{Shift+¿}
	labels = [Re, Im], axis = [gridlines = 6])	{Shift+¿}
	end proc:	{¿}
>	gra(li);	{¿}
>	lis := map(abs, li): gra(lis);	{¿}
>	with(plottools):	{Shift+¿}
	gram := proc(x)	{Shift+¿}
	local j, ne;	{Shift+¿}
	ne := NULL;	{Shift+¿}
	for j from 1 to nops(x) do	{Shift+¿}
	ne := (ne, [0, 0], [Re(li[j]), Im(li[j])])	{Shift+¿}
	end do:	{Shift+¿}
	polygon([ne])	{Shift+¿}
	end proc:	{¿}
>	g1 := gra(li); g2 := gram(li):	{Shift+¿}
	display(g1, g2);	{¿}